Sigmoid 函数

以下是上一道练习我的解决方案：

class Linear(Node):
    def __init__(self, X, W, b):
        # Notice the ordering of the inputs passed to the
        # Node constructor.
        Node.__init__(self, [X, W, b])

    def forward(self):
        X = self.inbound_nodes[0].value
        W = self.inbound_nodes[1].value
        b = self.inbound_nodes[2].value
        self.value = np.dot(X, W) + b

我的解决方案没有什么特别之处。我从相应的输入中获取了 X、W 和 b 的值。我使用了 np.dot 来处理矩阵乘法。

神经网络利用替代转换和激活函数更好地归类输出。S 型函数是最常用的激活函数之一。

Sigmoid 函数

线性变换可以进行简单的值变换，但是神经网络通常需要更细致的变换。例如，人工神经元的原始设计之一——感知机就会出现二级制输出行为。感知机将加权输入与阈值对比。当加权输入超过该阈值，感知机就会被激活并输出 1，否则输出 0。

你可以用阶梯函数表示感知机的行为。

激活（二进制输出行为这一概念）通常可以解决分类问题。例如，如果你要神经网络推测某个手写图片是否为 ‘9’，就相当于寻求二进制输出——是，是 ’9’，或者否，不是 ‘9’。阶梯函数是最纯粹的二进制输出形式，这很棒。但是，阶梯函数不是连续的，不可微，这很糟糕。可微分的函数才能产生梯度下降。

S 型函数（上述等式 (3)）将阈值替换成美观的 S 型曲线（如上所示），模仿出感知机的激活行为，并且保持连续性，因此可微分。此外，S 型函数具有非常简单的导数，和 S 型曲线本身非常相似。

注意 S 型函数只有一个参数。注意，S 型函数是激活函数（非线性），意味着它传入一个输入，并对其进行数学运算。

从概念上讲，S 型函数会做出决策。它会根据数据中的加权特征判断特征对某个分类产生影响。这样，S 型激活在线性变换后可以很好地运转。它现在具有随机权重和偏置，S 型节点的输出也是随机的。通过反向传播和梯度下降进行学习的流程（你很快就要实现这一点）会修改权重和偏置，使 S 型节点的激活开始于预期输出匹配。

注意，我已经提供了 S 型函数的等式。请将该等式添加到 MiniFlow 库中。为此，你需要使用 np.exp (documentation)，这样操作起来更轻松。

你将使用 Sigmoid 和 Linear，如下所示：

说明

打开 nn.py，看看网络是如何使用的 Sigmoid。
打开 miniflow.py。修改 Sigmoid 类的 forward 方法，以反映 S 型函数的行为。
测试你的代码！当 Sigmoid 能正常运转时，点击“提交”。

Start Quiz:

nn.py miniflow.py

"""
This network feeds the output of a linear transform
to the sigmoid function.

Finish implementing the Sigmoid class in miniflow.py!

Feel free to play around with this network, too!
"""

import numpy as np
from miniflow import *

X, W, b = Input(), Input(), Input()

f = Linear(X, W, b)
g = Sigmoid(f)

X_ = np.array([[-1., -2.], [-1, -2]])
W_ = np.array([[2., -3], [2., -3]])
b_ = np.array([-3., -5])

feed_dict = {X: X_, W: W_, b: b_}

graph = topological_sort(feed_dict)
output = forward_pass(g, graph)

"""
Output should be:
[[  1.23394576e-04   9.82013790e-01]
 [  1.23394576e-04   9.82013790e-01]]
"""
print(output)

"""
Fix the Sigmoid class so that it computes the sigmoid function
on the forward pass!

Scroll down to get started.
"""

import numpy as np

class Node(object):
    def __init__(self, inbound_nodes=[]):
        self.inbound_nodes = inbound_nodes
        self.value = None
        self.outbound_nodes = []
        for node in inbound_nodes:
            node.outbound_nodes.append(self)

    def forward():
        raise NotImplementedError


class Input(Node):
    def __init__(self):
        # An Input node has no inbound nodes,
        # so no need to pass anything to the Node instantiator
        Node.__init__(self)

    def forward(self):
        # Do nothing because nothing is calculated.
        pass


class Linear(Node):
    def __init__(self, X, W, b):
        # Notice the ordering of the input nodes passed to the
        # Node constructor.
        Node.__init__(self, [X, W, b])

    def forward(self):
        X = self.inbound_nodes[0].value
        W = self.inbound_nodes[1].value
        b = self.inbound_nodes[2].value
        self.value = np.dot(X, W) + b


class Sigmoid(Node):
    """
    You need to fix the `_sigmoid` and `forward` methods.
    """
    def __init__(self, node):
        Node.__init__(self, [node])

    def _sigmoid(self, x):
        """
        This method is separate from `forward` because it
        will be used later with `backward` as well.

        `x`: A numpy array-like object.

        Return the result of the sigmoid function.

        Your code here!
        """


    def forward(self):
        """
        Set the value of this node to the result of the
        sigmoid function, `_sigmoid`.

        Your code here!
        """
        # This is a dummy value to prevent numpy errors
        # if you test without changing this method.
        self.value = -1


def topological_sort(feed_dict):
    """
    Sort the nodes in topological order using Kahn's Algorithm.

    `feed_dict`: A dictionary where the key is a `Input` Node and the value is the respective value feed to that Node.

    Returns a list of sorted nodes.
    """

    input_nodes = [n for n in feed_dict.keys()]

    G = {}
    nodes = [n for n in input_nodes]
    while len(nodes) > 0:
        n = nodes.pop(0)
        if n not in G:
            G[n] = {'in': set(), 'out': set()}
        for m in n.outbound_nodes:
            if m not in G:
                G[m] = {'in': set(), 'out': set()}
            G[n]['out'].add(m)
            G[m]['in'].add(n)
            nodes.append(m)

    L = []
    S = set(input_nodes)
    while len(S) > 0:
        n = S.pop()

        if isinstance(n, Input):
            n.value = feed_dict[n]

        L.append(n)
        for m in n.outbound_nodes:
            G[n]['out'].remove(m)
            G[m]['in'].remove(n)
            # if no other incoming edges add to S
            if len(G[m]['in']) == 0:
                S.add(m)
    return L


def forward_pass(output_node, sorted_nodes):
    """
    Performs a forward pass through a list of sorted Nodes.

    Arguments:

        `output_node`: A Node in the graph, should be the output node (have no outgoing edges).
        `sorted_nodes`: a topologically sorted list of nodes.

    Returns the output node's value
    """

    for n in sorted_nodes:
        n.forward()

    return output_node.value

Next Concept